// 认证服务 - 使用 Supabase Auth 内置认证系统

import { supabase } from '../config/supabase';
import type { User, Session, AuthError } from '@supabase/supabase-js';

interface UserProfile {
  id: string;
  email: string;
  name?: string;
  role: string;
  created_at: string;
  updated_at: string;
}

interface AuthResponse {
  success: boolean;
  data?: {
    user: User & { profile?: UserProfile };
    session: Session;
    profile?: UserProfile | null;
  };
  message: string;
}

class AuthService {
  // 注册新用户
  async signUp(email: string, password: string, metadata?: { name?: string }): Promise<AuthResponse> {
    try {
      const { data, error } = await supabase.auth.signUp({
        email,
        password,
        options: {
          data: {
            name: metadata?.name || '用户'
          }
        }
      });

      if (error) {
        throw error;
      }

      if (!data.user) {
        throw new Error('注册失败，请重试');
      }

      // 创建用户配置文件
      if (data.user && data.session) {
        const profileCreated = await this.createUserProfile(data.user.id, {
          email: data.user.email!,
          name: metadata?.name,
          role: 'user'
        });

        if (!profileCreated) {
          // 如果创建用户配置文件失败，删除已创建的 Auth 用户
          await supabase.auth.admin.deleteUser(data.user.id);
          throw new Error('创建用户配置文件失败，请重试');
        }
      }

      return {
        success: true,
        data: {
          user: data.user,
          session: data.session!,
        },
        message: data.session ? '注册成功' : '注册成功，请检查邮箱验证链接'
      };
    } catch (error: any) {
      return {
        success: false,
        message: this.getErrorMessage(error)
      };
    }
  }

  // 用户登录
  async signIn(email: string, password: string): Promise<AuthResponse> {
    try {
      const { data, error } = await supabase.auth.signInWithPassword({
        email,
        password
      });

      if (error) {
        throw error;
      }

      if (!data.user || !data.session) {
        throw new Error('登录失败');
      }

      // 获取用户配置文件 - 必须存在才能登录成功
      const profile = await this.getUserProfile(data.user.id);
      
      if (!profile) {
        // 如果用户配置文件不存在，登出并返回错误
        await supabase.auth.signOut();
        throw new Error('用户配置文件不存在，请联系管理员');
      }

      return {
        success: true,
        data: {
          user: { 
            ...data.user,
            profile
          },
          session: data.session,
          profile
        },
        message: '登录成功'
      };
    } catch (error: any) {
      return {
        success: false,
        message: this.getErrorMessage(error)
      };
    }
  }

  // 用户登出
  async signOut(): Promise<{ success: boolean; message: string }> {
    try {
      const { error } = await supabase.auth.signOut();
      
      if (error) {
        throw error;
      }

      return {
        success: true,
        message: '登出成功'
      };
    } catch (error: any) {
      return {
        success: false,
        message: this.getErrorMessage(error)
      };
    }
  }

  // 获取当前用户
  async getCurrentUser(): Promise<User | null> {
    try {
      const { data: { user } } = await supabase.auth.getUser();
      return user;
    } catch (error) {
      console.error('获取当前用户失败:', error);
      return null;
    }
  }

  // 获取当前会话
  async getCurrentSession(): Promise<Session | null> {
    try {
      const { data: { session } } = await supabase.auth.getSession();
      return session;
    } catch (error) {
      console.error('获取当前会话失败:', error);
      return null;
    }
  }

  // 刷新会话
  async refreshSession(): Promise<{ session: Session | null; user: User | null }> {
    try {
      const { data, error } = await supabase.auth.refreshSession();
      
      if (error) {
        throw error;
      }

      return {
        session: data.session,
        user: data.user
      };
    } catch (error) {
      console.error('刷新会话失败:', error);
      return {
        session: null,
        user: null
      };
    }
  }

  // 监听认证状态变化
  onAuthStateChange(callback: (event: string, session: Session | null) => void) {
    return supabase.auth.onAuthStateChange((event, session) => {
      callback(event, session);
    });
  }

  // 创建用户配置文件
  private async createUserProfile(userId: string, profileData: {
    email: string;
    name?: string;
    role: string;
  }): Promise<boolean> {
    try {
      const { error } = await supabase
        .from('user_profiles')
        .insert({
          id: userId,
          email: profileData.email,
          name: profileData.name || '用户',
          role: profileData.role,
          created_at: new Date().toISOString(),
          updated_at: new Date().toISOString()
        });

      if (error) {
        console.error('创建用户配置文件失败:', error);
        return false;
      }

      return true;
    } catch (error) {
      console.error('创建用户配置文件异常:', error);
      return false;
    }
  }

  // 获取用户配置文件
  private async getUserProfile(userId: string): Promise<UserProfile | null> {
    try {
      const { data, error } = await supabase
        .from('user_profiles')
        .select('*')
        .eq('id', userId)
        .single();

      if (error) {
        // 区分表不存在和记录不存在的错误
        if (error.code === 'PGRST116') {
          console.error('用户配置文件记录不存在:', userId);
        } else if (error.code === '42P01') {
          console.error('user_profiles 表不存在，请先创建数据库表');
        } else {
          console.error('获取用户配置文件失败:', error);
        }
        return null;
      }

      return data;
    } catch (error) {
      console.error('获取用户配置文件异常:', error);
      return null;
    }
  }

  // 错误信息处理
  private getErrorMessage(error: AuthError | Error): string {
    if ('message' in error) {
      switch (error.message) {
        case 'Invalid login credentials':
          return '邮箱或密码错误';
        case 'Email not confirmed':
          return '请先验证您的邮箱';
        case 'User already registered':
          return '该邮箱已被注册';
        case 'Password should be at least 6 characters':
          return '密码至少需要6个字符';
        case 'Unable to validate email address: invalid format':
          return '邮箱格式不正确';
        case 'Signup is disabled':
          return '注册功能已禁用';
        default:
          return error.message;
      }
    }
    return '操作失败，请重试';
  }
}

export default new AuthService();